
\chapter{QUADRO METODOLÓGICO}
\thispagestyle{empty}

\par Neste capítulo são apresentados os procedimentos utilizados para a
realização do projeto de pesquisa. Segundo \citeonline{gil2010elaborar}, a
metodologia têm como objetivo descrever os procedimentos necessários para a realização de uma pesquisa. 

\par Os procedimentos escolhidos serão apresentados, iniciando-se pelo tipo de
pesquisa.
\section{Tipo de Pesquisa}

\par A busca pelo conhecimento de uma nova tecnologia de armazenamento de dados
foi a grande motivação para a realização deste projeto de pesquisa.
Segundo \citeonline[p. 17]{gil2010elaborar}, “pode-se definir pesquisa como o
procedimento racional e sistemático, que têm como objetivo proporcionar
respostas aos problemas que são propostos”. Para \citeonline{de2002metodologia},
\begin{citacao}
	Tomada num sentido amplo, pesquisa é toda atividade voltada para a solução de
	problemas; como atividade de busca, indagação, investigação, inquirição da
	realidade, é a atividade que vai nos permitir, no âmbito da ciência, elaborar
	um conhecimento, ou um conjunto de conhecimentos, que nos auxilie na
	compreensão desta realidade e nos oriente em nossas ações.
\end{citacao}

\par Com base nas definições citadas, uma pesquisa concentra-se na construção do
conhecimento, que se caracteriza por ser um processo longo e trabalhoso para
encontrar as respostas para determinados problemas. 

\par Para se fazer qualquer tipo de classificação é preciso que alguns
critérios sejam analisados previamente. Segundo \citeonline{gil2010elaborar}, um
dos principais critérios para classificação de uma pesquisa é com base em seu
objetivo geral, o que a divide em três grandes grupos: exploratória,
descritiva e explicativa. Seguindo este pensamento, esta pesquisa pode ser
classificada como exploratória pois tem como objetivo desenvolver uma aplicação
\textit{web} utilizando o banco de dados Neo4j com o intuito de obter uma maior
familiaridade com a ferramenta visto que esta é pouco conhecida.

\par Segundo \citeonline[p. 41]{gil2010elaborar},

\begin{citacao}
Estas pesquisas têm como objetivo proporcionar maior familiaridade com o
problema, com vistas a torná-los mais explícitos ou a construir hipóteses. Pode
se dizer que estas pesquisas têm como objetivo principal o aprimoramento de
idéias ou a descoberta de intuições.
\end{citacao}

\par Tendo definido o tipo de pesquisa, deve-se estabelecer o contexto ao qual o
trabalho se enquadra

\section {Contexto da pesquisa} 

\par As aplicações distribuídas necessitam de soluções de armazenamento que
atendam ao grande volume de dados e que sejam fáceis de escalar. Com isso os
profissionais responsáveis por administrar estas aplicações, 
devem conhecer diversas soluções que sejam compatíveis com as necessidades dos
usuários e que proporcionem um alto nível de qualidade ao usuário final.


\par Este trabalho é aplicado na área de persistência de dados, em que os dados
são armazenados e disponibilizados para uma determinada aplicação mediante a uma
solicitação, assim esses dados serão processados e se tornarão informações para
os clientes. Esse processo pode ser considerado crucial para o sucesso
de uma aplicação e por este motivo é importante haver vários tipos de
implementações deste recurso, de forma que possa atender aos vários tipos de
aplicações com diferentes requisitos. O trabalho se destina principalmente a
acadêmicos e profissionais que desenvolvem aplicações que não possuem uma
estrutura compatível com a oferecida pelo modelo relacional.

\section{Instrumento de pesquisa}

\par Para a realização do projeto foi feita uma análise do conteúdo pertinente
ao tema proposto. Este processo se valeu da leitura de bibliografias disponíveis
sobre os temas necessários para compor a base para o
desenvolvimento do projeto,  além da consulta a \textit{sites} oficiais da empresa
responsável pela criação e manutenção do banco de dados Neo4j. 
\par O primeiro passo foi definir os locais onde coletar as informações
importantes para garantir a autenticidade do texto. Posteriormente, os
documentos foram coletados e arquivados de forma que estivessem
disponíveis para consulta em qualquer lugar, para isso foi utilizada uma
ferramenta \textit{online} para armazenamento e compartilhamento de arquivos chamada Google 
Drive\footnote{\textit{Site}: \url{http://drive.google.com}}. Depois de
analisadas, as principais referências foram separadas de acordo com os critérios
da pesquisa.
\par Para a implementação do projeto proposto pela pesquisa foi utilizada a
IDE (\textit{Integrated Development Environment}) de desenvolvimento Eclipse, que figura entre as mais importantes
do mercado e possui suporte para diversas linguagens. Para a visualização
dos dados armazenados no banco de dados Neo4j foi utilizado o Neoclipse, uma
ferramenta usada para visualizar, editar e explorar bases de dados Neo4j
desenvolvida pela mesma empresa do Neo4j\footnote{Repositório do
projeto: \url{https://github.com/neo4j-contrib/neoclipse}}.


\section{Metodologia de desenvolvimento}

\par Nesta seção são apresentados os procedimentos que foram seguidos para a
realização do projeto, mostrando as ferramentas utilizadas para o
desenvolvimento e colaboração entre os participantes no desenvolvimento do
\textit{software}.

\subsection{Procedimentos gerais de desenvolvimento}

\par Para o desenvolvimento do projeto foi utilizada uma ferramenta de controle
de versão chamada Subversion (SVN), que permite que várias pessoas trabalhem em
um mesmo projeto, que gerencia diretórios e arquivos
além das modificações feitas neles no decorrer do
projeto \cite{koning2011automating}.
Esta ferramenta pode ser utilizada na IDE Eclipse através do \textit{plugin}
Subclipse que pode ser instalado, através de um link\footnote{\textit{Link} para
instalação dentro do Eclipse:
\url{http://subclipse.tigris.org/update\_1.10.x}}, dentro do Eclipse, adicionando-o à
interface de instalação de \textit{softwares} da IDE.
Para que seja possível utilizar o SVN é preciso ter um repositório onde possam ser
armazenados os arquivos do projeto e que esteja
disponível para todos participantes do projeto. Para o projeto foi utilizado um
repositório \textit{online} que fornece acesso SVN, gratuitamente, chamado
Google Code da empresa Google.


\subsection{Desenvolvimento utilizando a metodologia ICONIX}

\par O processo de desenvolvimento pode parecer trivial quando referencia-se
a projetos pequenos, mas à medida que aumenta a complexidade do
\textit{software}, fica mais difícil garantir a qualidade do produto final. O
surgimento das metodologias de desenvolvimento, juntamente com a estruturação da
\textit{Unified Modeling Language} (UML) têm contribuído com a criação,
definição e com a qualidade do processo de desenvolvimento. Segundo \citeonline[p. 12]{rezende2005engenharia} ``o principal desafio desta década é melhorar a qualidade (e reduzir custos) de soluções baseadas em computador, que são implementadas com \textit{software}''. Isso evidencia que hoje o criação de um sistema deve envolver processos que auxiliem no desenvolvimento de uma aplicação para que ela cumpra com os requisitos do cliente e atenda ao nível de qualidade esperado. 

\par Para o desenvolvimento do projeto foi utilizada a metodologia ICONIX, criada
na decáda de 80 por Rosenberg e Scott. Essa metodologia faz uso diagramas da
UML, uma linguagem de modelagem que especifica e documenta
o desenvolvimento de um \textit{software}, sendo dividida em suas quatro fases.

A seguir, o processo de desenvolvimento do \textit{software} será detalhado conforme o
padrão estabelecido pela metodologia ICONIX.

\subsubsection{Requisitos}
\par Os requisitos definem os recursos que serão empregados no projeto sobre as
necessidades do cliente e com base neles é possível criar o modelo de
domínio e os casos de uso. O levantamento dos requisitos foi feito de acordo com
as necessidades da pesquisa em questão, de forma que seja possível alcançar o
objetivo geral. A análise foi realizada com base em reuniões entre os autores e
o orientador, possibilitando uma visão mais ampla das funcionalidades que a aplicação deveria possuir.
\par Seguem abaixo os principais requisitos do sistema:

\begin{itemize}
    \item realizar o armazenamento de dados no banco Neo4j: o sistema deve realizar, de forma hábil, o armazenamento de informações em um banco NoSQL do tipo \textit{Graph Database} usando a API \textit{core Java} do Neo4j;
    \item fornecer ao usuário recomendações de filmes: o sistema deve ser capaz analisar as informações contidas no banco e ser capaz de gerar recomendações para os usuários de acordo com suas preferâncias;
    \item realizar registro de locação: o sistema deve ser capaz de vincular um usuário a um filme utilizando os recursos do Neo4j, assim como permitir que o usuário classifique o filme de acordo com uma nota de um a cinco;
   \item ser uma aplicação \textit{web}: o sistema deve ser capaz de rodar em uma navegador \textit{web}. 
\end{itemize}

\par Após o término da análise de requisitos, teve início a criação dos
diagramas de casos de uso e o modelo de domínio como é sugerido pela
metodologia de desenvolvimento.

\par O modelo de domínio pode ser visto como sendo a exemplificação dos objetos
tendo como base relações do mundo real. Ele basicamente é um diagrama de
classes em que não são especificados os atributos e os métodos e sua
função é ilustrar as principais entidades do sistema. Na
Figura~\ref{fig:dominio} é ilustrado o modelo de domínio do sistema.
  
\begin{figure}[h!]
  \centerline{\includegraphics[scale=.85]{./imagens/modelo_de_dominio_v4_08_12.png}}
  \caption[Modelo de domínio]{Modelo de Domínio. \textbf{Fonte:} Elaborado pelos
  autores}
\label{fig:dominio}
\end{figure}

\par Com o modelo de domínio é possível ter uma respresentação visual das classes
conceituais e de objetos do mundo real que representam o domínio do projeto.
Mesmo ainda não possuindo as operações de cada classe, é importante notar que
esse diagrama fornece uma clara compreensão das classes conceituais e seus
relacionamentos. 

\par Ao término da diagramação do modelo de domínio é dado início à elaboração 
do modelo de dos casos de uso (UC) que são utilizados para mostrar as
funcionalidades do sistema. Cada UC representa uma sequência de
ações que são desencadeadas por um ator ou entidade, com a finalidade de
alcançar um objetivo específico. Atores estabelecem vínculos diretos com alguns
casos de uso que,  segundo \citeonline{rosenberg2005agile}, representam o papel
que o usuário exercerá utilizando um sistema.
\par A partir dos requisitos do sistema foi possível realizar a elaboração do modelo de casos uso, representando as interações exercidas pelos usuários ao utilizar o sistema proposto neste projeto.

A Figura~\ref{fig:caso_uso_administrador} apresenta o modelo dos casos de uso
com os atores Administrador e Usuário, onde pode-se visualizar que foram exemplificados os requisitos definidos
anteriormente, como cadastrar filmes, gerenciar questionário juntamente com a funcionalidade do usuário em alugar filme. 

\begin{figure}[h!]
  \centerline{\includegraphics[scale=.8]{./imagens/caso_de_uso_admin_user_23_11_2013.png}}
  \caption[Casos de uso]{Casos de uso. \textbf{Fonte:} Elaborado
  pelos autores}
\label{fig:caso_uso_administrador}
\end{figure}
 
\par Tendo realizado a identificação de requisitos, a elaboração do modelo de
domínio e formulado os casos de uso, já é possível iniciar a análise e projeto
preliminar.

\subsubsection{Análise e projeto preliminar}
\par Nesta fase é realizada uma análise mais profunda, descrevendo o
funcionamento dos casos de uso e fornecendo informações das atividades
exercidas pelos atores no sistema. Este detalhamento é feito através dos fluxos de
eventos, que exibem, em sua estrutura, informações de eventos que ocorrem do início
ao fim da execução de um caso de uso. Ele apresenta um passo-a-passo que descreve todas
ações necessárias para que se consiga alcançar o objetivo de um determinado caso
de uso e fornece informações das ocorrências de eventos alternativos e como se
comporta o sistema.
Na próxima seção serão detalhados os casos de uso, demonstrando sua execução através
dos fluxos de eventos.
  
\par O primeiro caso de uso detalhado, refere-se ao
cadastro de filme, tendo como ator o Administrador, descrito pelo fluxo de eventos do Quadro~\ref{fig:fluxo_evento_cadastro_filme}.
\begin{quadro}[h!]
  %\centerline{\includegraphics[scale=.8]{./imagens/fluxo_evento_cadastro_filme.png}}

   \input{./fluxos/fluxo-evento-cadastro-filme}
   \caption[Fluxo de eventos para cadastro de filme]{Fluxo de eventos para cadastro
  de filme.
  \textbf{Fonte:} Elaborado pelos autores}
\label{fig:fluxo_evento_cadastro_filme}
\end{quadro}

\par No Quadro~\ref{fig:fluxo_evento_aluga_filme} é ilustrado o fluxo de
evento do aluguel de um filme pelo ator Usuário.
\begin{quadro}[h!]
  %\centerline{\includegraphics[scale=.8]{./imagens/fluxo_evento_user_aluga_filme_v2.png}}
  
  \begin{fluxoDeEventos}
  \addTitle{Alugar Filme}
  \addrow{Ator principal}{Administrador}
  %\addrow{Ator secundário}{Sistema}
  \addrow{Pré-requisitos}{Estar logado no sistema}

  \startBasicFlow{Ator} {Sistema}
  \addItemOne{Seleciona o filme}
  \addItemOne{Clica na opção alugar}
  \addItemTwo{Registra do processo de locação}
  
\end{fluxoDeEventos}
  
   \caption[Fluxo de eventos para locação de filme]{Fluxo de eventos para locação
  de filme.
  \textbf{Fonte:} Elaborado pelos autores}
\label{fig:fluxo_evento_aluga_filme}
\end{quadro}

\par Já no Quadro~\ref{fig:fluxo_evento_editar_filme} é detalhado o caso de uso para edição
das informações de um determinado filme cadastrado. Esta funcionalidade permite que o usuário atualize ou corriga alguma informação inserida no cadastro inicial do filme.

\begin{quadro}[h!]
  %\centerline{\includegraphics[scale=.8]{./imagens/fluxo_evento_editar_filme.png}}
  
  \begin{fluxoDeEventos}
  \addTitle{Editar filme}
  \addrow{Ator principal}{Administrador}
  %\addrow{Ator secundário}{Sistema}
  \addrow{Pré-requisitos}{Estar logado no sistema}

  \startBasicFlow{Ator} {Sistema}
  \addItemOne{Seleciona menu listar}
  \addItemOne{Clica na opção listar filmes}
  \addItemTwo{Abre interface contendo informações dos filmes cadastrados}
  \addItemOne{Seleciona filme}
  \addItemTwo{Preenche o formulário com as informações do filme selecionado}
  \addItemOne{Altera as informações do filme}
  \addItemOne{Clica no botão Salvar}
  \addItemTwo{Atualiza as informações do filme}

  \startAlternativeFlow{Fluxo alternativo 1}
  \addItemOne{No item 6, formulário não preenchido}
  \addItemTwo{Exibe mensagem de necessidade de preenchimento de formulário}

  %\startAlternativeFlow{Fluxo alternativo 2}
  %\addItemOne{No item 6, inserido filme já cadastrado}
  %\addItemTwo{Informa mensagem de filme já cadastrado}
\end{fluxoDeEventos}
  
   \caption[Fluxo de eventos para editar cadastro do filme]{Fluxo de eventos para
  editar cadastro do filme.
  \textbf{Fonte:} Elaborado pelos autores}
\label{fig:fluxo_evento_editar_filme}
\end{quadro}

\par Após a elaboração dos fluxos de eventos, foi iniciado o processo de
construção dos diagramas de robustez tendo como referência os fluxos 
elaborados na etapa anterior.
\par O diagrama de robustez possibilita a identificação dos objetos que não
foram descobertos no modelo de domínio, fornecendo informações que descrevem a
forma de trabalho do sistema. Nele são apresentadas o ator interagindo com as classes de fronteira,  bem como os \textit{controllers} e as \textit{Entities}.
\par Inicialmente foi realizada a implmentação do diagrama de robustez
referente ao caso de uso cadastrar filme, ilustrado na
Figura~\ref{fig:diagrama_robustez_cad_filme}.

\begin{figure}[h!]
  \centerline{\includegraphics[scale=.5]{./imagens/robustez_admin_cad_filme.png}}
  \caption[Diagrama de robustez: Cadastro de filme]{Diagrama de robustez: Cadastro
  de filme. \textbf{Fonte:} Elaborado pelos autores}
\label{fig:diagrama_robustez_cad_filme}
\end{figure}

\par Logo após ter efetuado a contrução do diagrama de robustez de cadastro de
filme, foi elaborado o diagrama referente ao aluguel do filme, ilustrado na
Figura~\ref{fig:diagrama_robustez_cad_filme2}.

\begin{figure}[h!]
  \centerline{\includegraphics[scale=.5]{./imagens/robustez_user_aluguel_aba_filme.png}}
  \caption[Diagrama de robustez: Aluguel de filme]{Diagrama de robustez: Aluguel
  de filme. \textbf{Fonte:} Elaborado pelos autores}
\label{fig:diagrama_robustez_cad_filme2}
\end{figure}

\par Depois de ter finalizado a elebotação dos diagramas de robustez, teve
início o processo da atualização do modelo de domínio inserindo os
atributos nas classes que foram descritas no modelo de domínio inicial, como é
apresentado na Figura~\ref{fig:diagrama_dominio_atributos}, onde os atributos
foram inseridos, tendo como base as características do mundo real.

\begin{figure}[h!]
  \centerline{\includegraphics[scale=.6]{./imagens/diagrama_dominio_atributos_v2.png}}
  \caption[Modelo de domínio atualizado com os atributos]{Modelo de domínio
  atualizado com os atributos. \textbf{Fonte:} Elaborado pelos autores}
\label{fig:diagrama_dominio_atributos}
\end{figure}

\par Após a atualização do diagrama de domínio foi realizada a revisão do
projeto preliminar, dando início à terceira fase do ICONIX, denominada análise
de projeto detalhado.

\subsubsection{Projeto detalhado}

\par Nesta fase foi detalhado o comportamento de cada caso de uso, utilizando
como meio de apresentação o diagrama de sequência, possibilitando que seja
vista a troca de mensagens entre os objetos.
 
 \par O primeiro diagrama de sequência, ilustrado na
 Figura~\ref{fig:sequence_admin_cad_filme_v2}, foi elaborado tendo como referência o caso
 de uso de cadastro de filmes, realizado pelo administrador.
 
 \begin{figure}[h!]
  \centerline{\includegraphics[scale=.6]{./imagens/diagrama_de_sequencia_cad_filme_08_12.png}}
  \caption[Diagrama de sequência representando um cadastro de filme]{Diagrama de
  sequência representando um cadastro de filme. \textbf{Fonte:} Elaborado pelos autores}
\label{fig:sequence_admin_cad_filme_v2}
\end{figure}

\par Os diagramas não inclusos nesta subseção estão disponíveis no
apêndice D. Após a elaboração dos diagramas de sequência, é
possível a criação do diagrama de classes, como pode ser visto na Figura
~\ref{fig:diagrama_de_classe_v2}, complementando o modelo de domínio
apresentando os relacionamentos entre as classes e seus respectivos métodos.



\begin{figure}[h!]
  \centerline{\includegraphics[scale=.9,angle=90]{./imagens/diagrama_de_classe_v2.png}}
  \caption[Diagrama de classes]{Diagrama de classes. \textbf{Fonte:} Elaborado
  pelos autores}
\label{fig:diagrama_de_classe_v2}
\end{figure}

\par Com o diagrama de classes finalizado, a terceira fase é encerrada dando
início a quarta e última fase do ICONIX onde serão apresentados os detalhes da
aplicação desenvolvida em cima de toda elaboração realizada com ICONIX.

\subsubsection{Desenvolvimento}

\par Com base nos diagramas elaborados nas fases anteriores, a implementação se
inicia com a modelagem do banco de dados. Pelo fato de o banco de dados
utlizado para construção do projeto possuir uma estrutra diferente da usualmente
utilizada nesta fase do processo de desenvolvimento, os acadêmicos optaram em
utilizar um modelo de grafos para ilustrar a modelagem do banco de dados,
ilustrada na Figura~\ref{fig:data_model}.

\begin{figure}[h!]
  \centerline{\includegraphics[scale=.6]{./imagens/data_model.png}}
  \caption[Modelagem do banco de dados]{Modelagem do banco de dados.
  \textbf{Fonte:} Elaborado pelos autores}
\label{fig:data_model}
\end{figure}

\par Com a elaboração do banco de dados, já é possível iniciar o processo de
implementação do projeto. Este processo consiste no desenvolvimento das
interfaces de interação com o usuário, a implementação das classes de controle e
de acesso ao banco de dados. É importante observar que diferentemente de um
banco de dados relacional, devendo o banco ser construído previamente para
ser utilizado pela aplicação, o Neo4j cria as entidades em tempo de execução,
bastando apenas definir as classes que irão manipular os dados que serão armazenados.


\par O Neo4j pode ser integrado ao projeto Java basicamente  de duas formas:
adiconando-o ao \textit{build path} do projeto ou por gerenciamento de
dependência utilizado pela ferramenta Maven. O Apêndice B mostra como adicionar o Neo4j ao projeto Java.


\par O desenvolvimento do sistema foi dividido em duas partes, a primeira foi a
codificação das classes de acesso ao banco de dados (DAO) e a segunda foi o
desenvolvimento das intefaces para o usuário (\textit{view}) e as classes
de controle (\textit{controllers}).

\par A primeira e mais importante classe de acesso ao banco é a
\texttt{Connection} ilustrada no Código~\ref{fig:connection_class}.

 \begin{lstlisting}[style=custom_Java,caption={[Classe \texttt{Connection}]Classe \texttt{Connection}. \textbf{Fonte:} Elaborado pelos autores}, label=fig:connection_class]
package br.edu.univas.locadoragraph.database;

import org.neo4j.graphdb.GraphDatabaseService;
import org.neo4j.graphdb.factory.GraphDatabaseFactory;

public class Connection {
	private static final String path = "database";
	private static Connection conn = null;
	private static GraphDatabaseService graph;

	private Connection() {}

	public static Connection getInstance() {
		if (conn == null) {
			conn = new Connection();
			graph = new GraphDatabaseFactory().newEmbeddedDatabase(path);
			registerShutdownHook(graph);
		}
		return conn;
	}

	public GraphDatabaseService newGraphDatabase() {
		return graph;
	}

	private static void registerShutdownHook(final GraphDatabaseService graph) {
		Runtime.getRuntime().addShutdownHook(new Thread() {
			@Override
			public void run() {
				graph.shutdown();
			}
		});
	}
}
\end{lstlisting}

 
\par A classe \texttt{Connection} é responsável por criar uma conexão com o
banco de dados Neo4j, ela utiliza o \textit{design pattern\footnote{Um padrão de
projeto é uma solução consolidada para um problema recorrente no desenvolvimento e manutenção de \textit{software}
orientado a objetos. \textbf{Fonte: } Apostila \textit{Design Pattern} K19
(\url{http://www.k19.com.br/downloads/apostilas/java/k19-k51-design-patterns-em-java})} singleton} para que possa existir apenas uma instância da classe e apenas uma instância do banco
de dados. Para criar uma instância do banco é preciso ter uma objeto
da classe \texttt{GraphDatabaseService} que é responsável por receber a instância do banco
que será usada em todas as operações envolvendo o banco de dados através do
código Java. Na linha 16 do Código~\ref{fig:connection_class} é possível observar que a instância do banco
é obtida através do método \texttt{newEmbeddedDatabase(path)} da classe
\texttt{GraphDatabaseFactory}. A mesma é atribuída ao objeto \texttt{graph} que
é retornado a cada chamada do método \texttt{newGraphDatabase()}. Como visto no
quadro teórico, toda instância do banco deve ser encerrada através do método
\texttt{shutdown()}. Como no projeto é utilizada apenas uma instância do banco,
foi criado o método \texttt{registerShutdownHook(final GraphDatabaseService
graph)} que recebe a instância do banco e executa o método \texttt{shutdown}
quando a \textit{virtual machine} (VM) é finalizada.

\par Para auxiliar no processo de criação de vértices e arestas no banco Neo4j,
foi criada a classe \texttt{Keys} e a classe do tipo enum\footnote{São tipos de dados composto de um conjunto fixo de constantes (\textit{static final}), sendo como uma lista de valores pré-definidos. \textbf{Fonte}: \textit{Enum} no Java (\url{http://www.devmedia.com.br/tipos-enum-no-java/25729})}
\texttt{RelTypes}. A classe \texttt{Keys}, ilustrada no
Código~\ref{fig:keys_class}, define as palavras-chave para a criação de \textit{indexes} e acesso ao vértices.

~\\
\begin{lstlisting}[style=custom_Java,caption={[Classe \texttt{Keys}]{Classe \texttt{Keys} \textbf{Fonte:} Elaborado pelos autores}}, label=fig:keys_class]
package br.edu.univas.locadoragraph.database;

public class Keys {
	//keys for index
	public static final String INDEXACTOR = "Actor";
	public static final String INDEXMOVIE = "Movie";
	public static final String INDEXDIRECTOR = "Director";
	public static final String INDEXGENDER = "Gender";
	public static final String INDEXUSER = "User";
	
	//keys for nodes
	public static final String ACTORKEY = "name";
	public static final String MOVIEKEY = "title";
	public static final String DIRECTORKEY = "name";
	public static final String GENDERKEY = "name";
	public static final String USERKEY = "email";
	
}
\end{lstlisting}

\par A classe \texttt{RelTypes} é uma classe do tipo \textit{enum} ilustrada
no Código~\ref{fig:reltypes_class}. Ela é uma classe de suma importância, pois, 
como visto no quadro teórico, toda aresta precisa ter um tipo definido e para isso ela implementa a
\textit{interface} \texttt{RelationshipType}.

\begin{lstlisting} [style=custom_Java,caption={[Classe \texttt{RelTypes}]{Classe \texttt{RelTypes}. \textbf{Fonte:} Elaborado pelos autores.}}, label=fig:reltypes_class]
package br.edu.univas.locadoragraph.database;

import org.neo4j.graphdb.RelationshipType;

public enum RelTypes implements RelationshipType
{
    DIRECTED,
    SERVED,
    BELONGS,
    WATCHED
}
\end{lstlisting}

\par Com base no diagrama de classes na terceira fase da metodologia de
desenvolvimento, é possível codificar as classes que serão utilizadas para
representar os objetos do modelo da aplicação, classes estas
conhecidas como \textit{Javabeans}\footnote{\textit{Javabeans} são classes que
possuem o construtor sem argumento e métodos de acesso do tipo
\texttt{get} e \texttt{set}. \textbf{Fonte: } Apostila \textit{Java Web}
Caelum (\url{http://www.caelum.com.br/apostila-java-web/})}. A classe
\texttt{UserTO}, ilustrada no Código~\ref{fig:userto_class}, representa uma das
classes \textit{javabeans} existentes no projeto.

\begin{lstlisting} [style=custom_Java,caption={[Classe \texttt{UserTO}]{Classe \texttt{UserTO}. \textbf{Fonte:} Elaborado pelos autores.}}, label=fig:userto_class]
public class UserTO {
	private String name;
	private String password;
	private String email;

	public String getName() { return name; }
	public String getPassword() { return password; }
	public String getEmail() { return email; }

	public void setName(String name) { this.name = name; }
	public void setPassword(String password) { this.password = password; }
	public void setEmail(String email) { this.email = email; }	
}

\end{lstlisting}


\par Para cada uma das classes descritas acima foram criadas classes DAO's
responsáveis por realizar as ações de CRUD. Para compreender
a lógica de uma classe DAO, será apresentada uma sequência de listagens com
trechos de código da classe \texttt{MovieDAO}, iniciando pelos atributos e construtor, através do
Código~\ref{fig:atributos_moviedao_class}.

\begin{lstlisting} [style=custom_Java,caption={[Atributos e construtor da classe \texttt{MovieDAO}]{Atributos e construtor da classe \texttt{MovieDAO}. \textbf{Fonte:} Elaborado pelos autores.}}
,label=fig:atributos_moviedao_class]
...

private Connection conn = null;
private RelationshipGraph relationships;
	public MovieDAO(){
		conn = Connection.getInstance();
		relationships = new RelationshipGraph();
	}
...
\end{lstlisting}



\par Este código mostra os dois
atributos privados da classe \texttt{MovieDAO}. O primeiro atributo é o
\texttt{conn} do tipo \texttt{Connection} cuja finalidade é
prover uma instância do banco para que os dados possam ser armazenados e
recuperados. Já o atributo \texttt{relationship} é utilizado para criar as
arestas entre os vértices. A classe \texttt{RelationshipGraph} é ilustrada no
Código~\ref{fig:relationship_class}, os métodos serão apresentados conforme sua
necessidade.

\begin{lstlisting} [style=custom_Java,caption={[Classe \texttt{RelationshipGraph}]{Classe \texttt{RelationshipGraph}. \textbf{Fonte:} Elaborado pelos autores.}}, label=fig:relationship_class]
public class RelationshipGraph {
	
	public void createRelationshipMovieActor(
		GraphDatabaseService graph, Node movie, MovieTO movieTo){
		...
	}	
	public void createRelationshipMovieDirector(
		GraphDatabaseService graph, Node movie, MovieTO movieTo){
		...
	}	
	public void createRelationshipMovieGender(
		GraphDatabaseService graph, Node movie, MovieTO movieTo) {
		...
	}
	public static boolean createRelationshipUserMovie(
		GraphDatabaseService graph, Node user, String titleMovie) {
		..
	}
}
\end{lstlisting}


\par Os métodos da classe \texttt{MovieDAO} foram contruídos com base nos
requisitos principais do sistema. São eles:

\begin{itemize}
  \item \texttt{saveMovieGraph(MovieTO movie)}: salva um filme no banco de
  dados. Recebe como parâmetro um objeto \texttt{MovieTO} e retorna
  \textit{true} quando o filme é salvo e \textit{false} caso não seja salvo com sucesso;
  \item \texttt{updateMovieGraph(MovieTO movie, String key)}: atualiza os dados
  de um filme. Recebe como  parâmetro um objeto \texttt{MovieTO}
  com os novos dados do filme e uma \textit{String} com a chave de acesso ao vértice que
  contém as informações antigas do filme;
  \item \texttt{getAllMovie()}: encontra e retorna todos os filmes cadastrados.
  Retorna um objeto \texttt{List<MovieTO>} contendo todos os filmes
  cadastrados;
  \item \texttt{getNodeMovie(GraphDatabaseService graph, String key)}: retorna o
  vértice do banco de dados que possui a chave \texttt{key}. Retorna um
  \texttt{Node} com as propriedades do vértice.
\end{itemize}

\par No Código~\ref{fig:savemovie_method} é exibido o trecho referente ao método \texttt{saveMovieGraph}.

\begin{lstlisting} [style=custom_Java,caption={[Método \texttt{saveMovieGraph(\ldots)}]{Método \texttt{saveMovieGraph}. \textbf{Fonte:} Elaborado pelos autores.}},label=fig:savemovie_method]
public boolean saveMovieGraph(MovieTO movie){

	GraphDatabaseService graph = conn.newGraphDatabase();
	Index<Node> index = graph.index().forNodes(Keys.INDEXMOVIE);		
	Node node = index.get(Keys.MOVIEKEY, movie.getTitle().toLowerCase()).getSingle();
	
	if (node == null) {
		Transaction tx = graph.beginTx();
		try {
			node = graph.createNode();
			node.setProperty(Keys.MOVIEKEY, movie.getTitle().toLowerCase());
			node.setProperty("year", movie.getYear());
			node.setProperty("sinopse", movie.getSinopse());
			index.add(node, Keys.MOVIEKEY, movie.getTitle().toLowerCase());
			relationships.createRelationshipMovieActor(graph, node, movie);
			relationships.createRelationshipMovieDirector(graph, node, movie);	
			relationships.createRelationshipMovieGender(graph, node, movie);
			
			tx.success();
			tx.finish();
			
			return true;
		} catch (Exception e) {
			tx.failure();
			tx.finish();
		} 
	}
	return false;
}
\end{lstlisting}


\par Em todos os métodos de acesso ao banco é necessário se obter uma
instância do banco, que é criada na classe \texttt{Connection}. Isto é feito
chamando o método \texttt{newGraphDatabase()} do objeto \texttt{graph}.
Com uma instância do banco de dados, é possível realizar diversos tipos de operações no banco como criar um \textit{index}, que é utilizado para agrupar vértices e
arestas de forma a facilitar a sua consulta. Para criar um objeto
\texttt{Index<Node>} é necessário chamar o método \texttt{index()}
do objeto \texttt{graph}. Esse método retorna um \texttt{IndexManager} e através
dele é possível criar um índice para um vértice, chamando o método
\texttt{forNodes(Keys.INDEXMOVIE)}. O atributo estático \texttt{Keys.INDEXMOVIE}
define o nome do índice.

\par Na linha 5 do Código~\ref{fig:savemovie_method}, é feita uma
pesquisa no banco para ver se existe um vértice com a mesma chave do filme que
será cadastrado. Para esse tipo de consulta, é preciso criar um objeto
\texttt{Node} com a finalidade de armazanar o vértice que será retornado. Com o
objeto \texttt{index}, que já foi carregado com as informações pertinentes a um
\textit{index} para filmes, é chamado o método \texttt{get(Keys.MOVIEKEY,
movie.getTitle().toLowerCase())}. O método \texttt{get} retorna uma
correspondência exata do índice composto por um par chave/valor em um
objeto \texttt{IndexHits}. Para se obter um objeto \texttt{Node} é necessário
chamar o método \texttt{getSingle()}, que retorna o primeiro vértice do
interador \texttt{IndexHits} ou \texttt{null} caso o vértice não seja
encontrado.

\par Caso não exista um vértice com a mesma chave do filme que será cadastrado,
o processo de cadastro é iniciado por uma transação através do método
\texttt{beginTx()}. Como visto, no Neo4j todas as operações que fazem uma
alteração nos dados cadastrados devem ser feitas dentro de uma transação. Este
processo é feito dentro de um bloco \texttt{try} e, caso seja lançada uma
exceção, é chamado o método \texttt{failure()}, que é similar ao
\texttt{rollback} de uma banco relacional. Caso a operação seja executada
corretamente o método \texttt{success()} é chamado, efetuando um \texttt{commit} na
transação, e para finalizar é chamado o método \texttt{finish()}.

\par Depois de iniciada a transação, tem início o processo de criação do
vértice, primeiramente cria-se um \texttt{node} através do método
\texttt{createNode()}. Com o vértice criado, são adicionadas as propriedades
referentes ao filme. Para padronizar os dados inseridos no banco, todas as
\texttt{strings} são armazenadas em caixa baixa, sendo isso feito com o método
\texttt{toLowerCase()}. Depois de atribuir as propriedades ao vértice, o mesmo é
adicionado ao índice com o método \texttt{add(\ldots)}.

\par Como visto nos diagramas, o filme possui relacionamentos com atores,
diretor e gênero, além do relacionamento com o usuário que será visto em outro
momento. Em um banco orientado a grafos estes relacionamentos são representados
por arestas, que são criadas pelos métodos
\texttt{createRelationshipMovieActor(\ldots)},
\texttt{createRelationshipMovieDirector(\ldots)} e 
\texttt{createRelationshipMovieGender(\ldots)}.

\par O Código~\ref{fig:relationship_actor} mostra a lógica de negócio para criar um relacionamento entre um filme e um ator.

\begin{lstlisting} [style=custom_Java,caption={[Método \texttt{createRelationshipMovieActor(\ldots)}]{Método \texttt{createRelationshipMovieActor(\ldots)}. \textbf{Fonte:} Elaborado pelos autores.}}, label=fig:relationship_actor]
public void createRelationshipMovieActor(GraphDatabaseService graph, Node movie, MovieTO movieTo){

	ArrayList<String> actors = movieTo.getActors();
	Index<Node> index = graph.index().forNodes(Keys.INDEXACTOR);
	Relationship relationship;
	for (String actor : actors) {
		Node node = index.get(Keys.ACTORKEY, actor.toLowerCase()).getSingle();
		relationship = node.createRelationshipTo(movie, RelTypes.SERVED);
	}
}
\end{lstlisting}


\par Os parâmetros passados este método são:

\begin{itemize}
  \item \texttt{GraphDatabaseService}: instância do banco;
  \item \texttt{Node}: vértice do filme que está sendo cadastrado;
  \item \texttt{MovieTO}: objeto contendo as informações do filme.
\end{itemize}

\par Na linha 3 deste código, é carregado um \texttt{ArrayList<String>} com
todos os atores que atuaram no filme, que são retornados pelo método
\texttt{getActors()}. Para recuparar os vértices no banco, foi necessário criar
um índice para atores e, depois de criada, um objeto do tipo
\texttt{relationship} é feito um \textit{loop} para iterar cada ator e criar
um relacionamento do tipo \texttt{SERVED} com o filme através do método
\texttt{createRelationshipTo(\ldots)}.

\par Algumas das funções mais importantes do projeto são as responsáveis pela
travessia do grafo, pois refletem diretamente no resultado do projeto de
pesquisa. Um dos métodos responsáveis por este recurso do \textit{software} é o
\texttt{getEcommendationMovieForActor(String user)}, ilustrado no
Código~\ref{fig:method_traveser}. 


\begin{lstlisting} [style=custom_Java,caption={[Método \texttt{getMoviesActor(\ldots)}]{Método \texttt{getMoviesActor(\ldots)}. \textbf{Fonte:} Elaborado pelos autores.}}, label=fig:method_traveser]
public List<MovieTO> getEcommendationMovieForActor(String user){
	List<MovieTO> movies = new ArrayList<MovieTO>();
	GraphDatabaseService graph = conn.newGraphDatabase();
	Traverser traverser = null;
	Index<Node> index = graph.index().forNodes(Keys.INDEXUSER);
		
	Node node = index.get(Keys.USERKEY, user.toLowerCase()).getSingle();
	if (node != null) {
		TraversalDescription td = Traversal.description()
				.depthFirst()
				.relationships(RelTypes.WATCHED, Direction.OUTGOING)
				.relationships(RelTypes.SERVED, Direction.INCOMING)
				.relationships(RelTypes.SERVED, Direction.OUTGOING)
				.evaluator(Evaluators.atDepth(3));

		traverser = td.traverse(node);
		for (Path path : traverser) {
			MovieTO movieTO = new MovieTO();
			movieTO.setTitle((String) path.endNode().getProperty(Keys.MOVIEKEY));
			movieTO.setYear((int) path.endNode().getProperty("year"));
			movieTO.setSinopse((String) path.endNode().getProperty("sinopse"));
			movies.add(movieTO);
		}
	}
	return movies;
}
\end{lstlisting}

\par Através deste método é possivel recuparar
todos os filmes e os atores que atuaram nestes filmes, que o usuário já assistiu, 
gerando assim uma recomendação ao usuário. Analisando o código, é
possível observar que, assim como a maioria dos métodos apresentados, é
necessário obter uma instância do bando de dados. O usuário criado
na linha 7 é necessário para que a travessia possa ser iniciada, pois
como foi visto no quadro teórico, todo caminho deve possuir um \textit{start node}.


\par Após validar a existência do vértice do usuário passado por parâmetro é que
tem início o processo de travessia. Para isso é criado um objeto do tipo
\texttt{TraversalDescription} responsável por armazenar as informações
sobre como será feita a travessia pelo grafo armazenado no banco de dados. A
travessia feita para retornar a lista de atores começa com a instrução
\texttt{depthFirst()}, que define que a busca será por profundidade. Definido o
tipo de travessia, foram definidas quais arestas são atravessadas pelo método
\texttt{relationships(\ldots)} onde os parâmetros passados são: o tipo da aresta
que será percorrida e a direção respectivamente. Então as arestas escolhidas
foram:
\begin{itemize}
  \item arestas que saem do usuário  e que são do tipo \texttt{WATCHED} (assistiu);
  \item arestas que saem do filme e que são do tipo \texttt{SERVED} (atuou);
  \item arestas que incidem sobre o ator e que são do tipo \texttt{SERVED} (atuou).
\end{itemize}

\par Com o trajeto já definido, é necessário definir quais vétices serão
retornados da travessia. Para recuperá-los, foi utilizado o método
\texttt{evaluator(\ldots)} e a única avaliação requerida é que a
travessia retorne apenas os vértices da terceira camada do grafo, isto é,
iniciando pelo \textit{start node} que é a camada zero (0), o próximo vértice
conectado a ele está na camada um (1). A Figura~\ref{fig:traverser_depht}
ilustra o trajeto percorrido, seguindo os critérios estabelecidos, e mostra o vértice de
profundidade três que será adicionado ao resultado.
 
\begin{figure}[h!]
 \centerline{\includegraphics[scale=0.8]{./imagens/travessia_exemplo.png}}
\caption[Camadas em uma busca em profundidade]{Camadas em uma busca em
profundidade.
 \textbf{Fonte:}
 Elaborado pelos autores}
\label{fig:traverser_depht}
\end{figure}

\par Depois de definido como será feita a travessia, é chamado o método
\texttt{traverse} que inicia a travessia pelo grafo e para isso recebe como
parâmetro o vértice do usuário para ser o \textit{start node}. O caminho é
armazenado no objeto \texttt{traverser}, iterado pelo
\textit{loop} e armazenado no objeto \texttt{path}. Dentro do \textit{loop}
as propriedades do vértice são atribuídas ao objeto \texttt{movieTO} que depois
de carregado é adicionado à lista \texttt{movies}.

\par Como citado anteriormente, o projeto teve sua implementação norteada em
dois processos fundamentais: a implementação do banco de dados orientado a grafo
e a implementação da \textit{view} utilizando a tecnologia JSF, que ocorreram
paralelamente vinculando suas necessidades de requisitos. A partir deste ponto
serão descritos os passos realizados para a implementação das páginas JSF sendo
dividida entre páginas XHTML e classes \textit{Bean}.

\par Inicialmente, com a IDE Eclipse JavaEE instalada, foi necessário realizar a
configuração do ambiente que permitisse criar páginas utilizando a
especificação JSF. Esta configuração foi realizada utilizando funcionalidades
da IDE, sendo desnecessária a manipulação de qualquer meio externo para
obtenção de arquivos para aus finalização. Para permitir uma
harmonização no conteúdo apresentado optadou-se por
apresentar todo este processo de configuração e instalação no Apêndice A.

\par Após a inclusão dos arquivos \textit{jar} do \textit{PrimeFaces} no
projeto, os mesmos também foram incluídos na pasta\texttt{ WEB\_INF/lib}, pois desta
forma é possível evitar problemas de
carregamento referentes aos componentes dessa biblioteca.


\par Para facilitar o desenvolvimento da interface visual foi utilizada a
\textit{Primefaces(bluesky)} que é um tema do \textit{Framework CSS ThemeRoller} que
está integrado ao \textit{PrimeFaces}. Para usar o tema foi necessário fazer o
\textit{download} do \textit{jar},  adicioná-lo ao \textit{classpath} e
configurar o \textit{PrimeFaces} para utilizá-lo. Esta configuração é feita no
arquivo \texttt{web.xml}, como é ilustrado na Figura~\ref{fig:bluesky}. 
 
\begin{figure}[ht]
\begin{lstlisting} [style=custom_XML]
	...
	<context-param>
		<param-name>primefaces.THEME<\param-name>
		<param-value>bluesky<\param-value>
	<\context-param>
	...
\end{lstlisting}
\caption[Incluindo o tema \textit{BlueSky} ao contexto do projeto]{Incluíndo o
tema \textit{BlueSky} ao contexto do projeto.
\textbf{Fonte:} Elaborado pelos autores.}
\label{fig:bluesky}
\end{figure}

\par Após a configuração do \textit{PrimeFaces} iniciou-se o processo de
desenvolvimento das páginas \textit{web} em XHTML, que possibilitam a utilização
das \textit{taglibs}. Foram adicionadas duas novas \textit{taglibs} que são
referenciadas pelo atributo \texttt{xmlns} (\textit{XML Name Space}) que indica todas as
bibliotecas utilizadas no arquivo XHTML. Foi incluso a \textit{taglib} que referencia a implementação
\textit{priemefaces} com o atributo \texttt{xmlns:p}, e ao final dessa configuração foi
possível utilizar os componentes da biblioteca \textit{primafaces}. Na
Figura~\ref{fig:taglibprimefaces} são apresentadas as \textit{taglibs} utilizadas
como padrão para outras páginas XHTML.

\begin{figure}[h!]
\begin{lstlisting} [style=custom_XML]
<?xml version="1.0" encoding="ISO-8859-1" ?>  
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"  
    xmlns:h="http://java.sun.com/jsf/html"  
    xmlns:f="http://java.sun.com/jsf/core"  
    xmlns:p="http://primefaces.org/ui"
    xmlns:ui="http://java.sun.com/jsf/facelets">   
  
    <h:head> 
      <f:facet name="first">
         <meta http-equiv="X-UA-Compatible" content="EmulateIE8" />
         <meta content="text/html; charset=UTF-8" http-equiv="Content-Type"/>
            <title>Locadora - Graph</title>
        </f:facet>
       <link type="text/css" rel="stylesheet" 
       						href="#{request.contextPath}/admin/css/cadastroFilme.css" /> 
      
    </h:head>  
\end{lstlisting}
\caption[Incluindo a \textit{taglib} \textit{primefaces}]{Incluindo a taglib \textit{primefaces}.
\textbf{Fonte:} Elaborado pelos autores.}
\label{fig:taglibprimefaces}
\end{figure}

\par Tendo confirmado o sucesso do funcionamento dos componentes da biblioteca
\textit{primefaces}, foi iniciada a construção da página responsável pelo
cadastro de filmes como sendo a primeira página de referência da aplicação deste projeto.
Foram utilizados nesta página inicial conceitos já citados em teoria, como uso
de \textit{expression language} que tem dentre suas funções definir e obter dados. No
cadastro apresentado, as expressões definem imagens utilizadas no \textit{layout} e
também são utilizadas para referenciar objetos na classe \texttt{FilmeBean}. 
Na Figura~\ref{fig:utilizacaodelayout} são apresentados algumas das
\textit{tags} do \textit{primefaces} que agilizaram o processo de construção das
páginas XHTML. 

\begin{figure}[h!]
\begin{lstlisting} [style=custom_XML]
...
<h:body>      
  <p:layout style="min-width:400px;min-height:600px;" id="layout" fullpage="true">  
    <p:layoutUnit position="north" size="100"  resizable="true" closable="true" 
      				collapsible="true" style="min-width:400px;min-height:160px;">  
	      <h:form> 
	          <ui:include src="layout/toolbarAdmin.xhtml" />
	          <center><h:graphicImage  value="#{resource['img:logograph_banner.png']}"/>
	          </center>
	      </h:form>
    </p:layoutUnit>
  ...
\end{lstlisting}
\caption[Utilização de \textit{layout primefaces} ]{Definições de \textit{layout primefaces}.
\textbf{Fonte:} Elaborado pelos autores.}
\label{fig:utilizacaodelayout}
\end{figure} 

O exemplo desta figura utiliza \textit{tags} como a \textit{tag} \texttt{<p:layout>} 
define um \textit{container} de página facilitando a construção da divisão de conteúdo na tela e
é formado por componentes \texttt{<p:layoutUnit>} que tem como principal função
orientar a posição de onde determinado conteúdo irá se posicionar. Utilizou-se da
propiedade \textit{position} composto pelos principais pontos cardiais
\textit{north, south, west, east}, apresentando uma facilidade na construção da
página. Tambem são apresentadas \textit{tags} como \texttt{<ui:include>} e
\texttt{<ui:graphicImage>} que têm como principal função incluir arquivos
externos. Esta funcionalidade possibilitou integrar arquivos tidos como padrão
nas diferentes telas criadas para essa aplicação, tendo assim um aumento de produtividade.


\par Após a definição do \textit{layout}, foram aplicados componentes que envolvem a construção
de formulários. Na Figura~\ref{fig:incluindotagsdeformulario}, foram incluídos
componentes tidos como essenciais para qualquer formulário. 

\begin{figure}[h!]
\begin{lstlisting} [style=custom_XML]     
    <f:facet name="header"> CADASTRO DE FILME </f:facet> 
    <p:layoutUnit position="center" style="overflow:hidden; height:400px;" size="400" >   
      <h:form style="overflow:hidden;">
        <p:growl></p:growl>
         <h:panelGrid columns="2" >
            <p:outputLabel>Titulo</p:outputLabel>
            <p:inputText id="nome"  value="#{filmeBean.movieTO.title}" required="true">   
              <f:validateLength minimum="3" />
            </p:inputText>
            <h:outputLabel>Ano</h:outputLabel>
            <p:inputText id="ano" value="#{filmeBean.movieTO.year}" required="true" 
                          requiredMessage="Ano Obrigatorio">
            	<f:validateLength minimum="3" />
            </p:inputText>      
        	<p:outputLabel>Genero</p:outputLabel>
        	<p:selectOneMenu id="indicador" value="#{filmeBean.movieTO.gender}">
	        	<f:selectItem itemValue=" " itemLabel="Categoria" />
	        	<f:selectItem itemValue="Aventura" itemLabel="Aventura" />
	        	<f:selectItem itemValue="Acao" itemLabel="Acao" />
	        	<f:selectItem itemValue="Drama" itemLabel="Drama" />
	        	<f:selectItem itemValue="Comedia" itemLabel="Comedia" />
	     	</p:selectOneMenu>
      		<h:outputLabel>Diretor</h:outputLabel>
          	...
          	</h:panelGrid>
	        
\end{lstlisting}
\caption[\textit{Tags} de formulário]{\textit{Tags} de formulário.
\textbf{Fonte:} Elaborado pelos autores.}
\label{fig:incluindotagsdeformulario}
\end{figure} 

Como entradas de
texto, foi utilizada a \textit{tag} \texttt{<p:inputText>}
que é semelhante à \textit{tag} \texttt{<input>} do HTML, com entrada
de dados e validação utilizando a propiedade \texttt{required}. A grande
diferença deste componente é a funcionalidade de acessar objetos das classes
\textit{Bean} utilizando como ponte a \textit{Expression Language}. Também
foram utilizados validadores através da \textit{tag} \texttt{<f:validateLength
minimum="3" />} que torna dispensável a utilização de validações explícitas de JavaScript
para limitação de caracteres.


\par Após ter inserido os componentes de entrada de texto, foi necessário
aplicar um componente que agrupasse os diferentes tipos de gênero de filmes
aplicados a esse sistema. Para esse propósito foi utilizada a \textit{tag}
\texttt{<p:selectOneMenu>} que possui como funcionalide integrar itens para
fornecer opções de escolha. Sua utilização não é muito diferente do padrão
HTML,  tendo como diferencial a utilização da \textit{Expression Language} para
acesso a objetos, e uma das vantagens em utilizar essas expressões é que neste
exemplo da figura~\ref{fig:incluindoselectdeitens}, no campo referente ao
diretor, é utilizada a \textit{Expression Language} para acessar uma lista na
classe \texttt{DirectorBean} que alimenta este componente com os nomes dos
diretores cadastrados no sistema.
\begin{figure}[h!]
\begin{lstlisting} [style=custom_XML]   
        	<p:outputLabel>Genero</p:outputLabel> 
	        <p:selectOneMenu id="indicador" value="#{filmeBean.movieTO.gender}">
	          	<f:selectItem itemValue=" " itemLabel="Categoria" />
	         	<f:selectItem itemValue="Aventura" itemLabel="Aventura" />
	         	<f:selectItem itemValue="Acao" itemLabel="Acao" />
	         	<f:selectItem itemValue="Drama" itemLabel="Drama" />
	         	<f:selectItem itemValue="Comedia" itemLabel="Comedia" />
	        </p:selectOneMenu>
	      	<h:outputLabel>Diretor</h:outputLabel>
	        <p:selectOneMenu id="iddirectors" value="#{filmeBean.movieTO.director}">
	             <f:selectItem itemValue="" itemLabel="Selecione" />
	             <f:selectItems value="#{directorBean.allDirector}"  
	                           var="director"  itemLabel="#{director.name}" 
	                           itemValue="#{director.name}"/>    
	      	</p:selectOneMenu>
	       </h:panelGrid>
\end{lstlisting}
\caption[Incluindo \textit{select} de itens]{Incluindo \textit{select} de itens.
\textbf{Fonte:} Elaborado pelos autores.}
\label{fig:incluindoselectdeitens}
\end{figure} 

\par Logo após ter definido e montado partes essenciais do formulário foi, necessário
elaborar uma forma de selecionar atores independente da quantidade existente e que porporcionasse 
uma usabilidade aceitável. Para seleção dos atores que iriam compor os filmes no
momento do cadastro, visto que a entrada de dados através de texto era inviável,
optou-se por utilizar um componente \textit{picklist} que é demonstrado na
Figura~\ref{fig:incluindopicklist} através da \textit{tag} \texttt{<p:pickList>}. 
Este componente permitiu a seleção de atores em uma lista repleta de nomes
cadastrados no banco, mas não necessariamente ligados a um determinado filme. A
funcionalidade de incluir na lista de selecionados ou devolver a lista de não
selecionados, proporcionou uma solução para este problema.
Nesta figura também pode ser visto o componente responsável por submeter o
formulário representado pela \textit{tag} \texttt{<p:commandButton>}, que
faz, através da propiedade \textit{actionListener}, a chamada direta ao
método \texttt{saveMovie} do objeto \texttt{filmeBean}, desta forma executando a finalização do cadastro.

\begin{figure}[h!]
\begin{lstlisting} [style=custom_XML]   	       
	...
	<h:panelGrid columns="2">
	   <p:outputLabel>Atores</p:outputLabel>
	   <p:pickList id="pickList" value="#{filmeBean.listActors}" var="listActors"   
	            itemLabel="#{listActors}" itemValue="#{listActors}"   />  
	   <p:outputLabel>Sinopse</p:outputLabel>
	   <p:inputTextarea value="#{filmeBean.movieTO.sinopse}"></p:inputTextarea>
	   <p:commandButton actionListener="#{filmeBean.saveMovie}" 
	                    value="Enviar" ajax="false">
	   </p:commandButton>
	</h:panelGrid>
  ...
\end{lstlisting}
\caption[Incluindo componente \textit{picklist} para os atores]{Incluindo componente \textit{picklist} para atores.
\textbf{Fonte:} Elaborado pelos autores.}
\label{fig:incluindopicklist}
\end{figure}

\par Após o término do \textit{layout} da página \texttt{cadastroFilme.xhtml}, foi
implementada a classe \texttt{FilmeBean} elaborada para ser responsável por
gerenciar as informações da tela de cadastro de filme. Alguns dos conceitos
citados no quadro teórico como as \textit{Annotations} foram utilizadas para nomear a classe de forma
que fosse reconhecida pelas páginas XHTML e definir o comportamento após uma
requisição feita a essa classe. Também foi implementado o objeto
\texttt{movieTo} necessário para fornecer uma permissão de acesso entre as páginas XHTML e a
classe \texttt{MovieTO} para utilizar como referência direta nas \textit{Expression Languages}
presentes nas páginas. Foram criados os métodos responsáveis por
alimentar os componentes da tela \texttt{cadastroFilme} com informação gerada por uma
requisição do banco de dados e métodos responsáveis por gerenciar requisições e
submissões feitas a essa classe. No Código~\ref{fig:classefilmebean} é
apresentada a classe \texttt{FilmeBean} tendo como primeira linha a
\textit{Annotation} \texttt{ManagedBean} com o nome de \texttt{filmeBean}. 

~\\

\begin{lstlisting} [style=custom_Java,caption={[Classe \texttt{FilmeBean}]{Classe \texttt{FilmeBean}. \textbf{Fonte:} Elaborado pelos autores.}},label=fig:classefilmebean] 	
@ManagedBean(name="filmeBean")
@SessionScoped
public class FilmeBean implements Serializable {
	private static final long serialVersionUID = 1L;
	private String nome;
	private String year;
	private MovieTO movieTo;
	private MovieDAO movieDAO;
	private List<MovieTO> listFilmes;
	private MovieTO selectedFilme;
	private DualListModel<String> listActors;
	private ActorDAO actorDao;
	private HtmlInputText cleanField;
	...
\end{lstlisting}


Para o gerenciamento da página de cadastro de filmes, também foi utilizado a
\textit{Annotation} de escopo \texttt{@SessionScoped} que armazena em sessão a
classe \texttt{FilmeBean}, desta forma a classe tem as informações disponíveis
idependente do término da requisição. Foram definidos todos os objetos
necessários para a transição entre as classes DAO e as páginas XHTML.

\par Também foram criados os métodos para
 manipular as requisições e alimentar alguns dos componetes de
cadastro de filme. No Código~\ref{fig:metodosclassebean} são apresentados os 
métodos importantes para o cadastro, responsável por enviar o objeto \texttt{movieTo} para a classe \texttt{MovieDAO}.


\begin{lstlisting} [style=custom_Java,caption={[Métodos da classe \texttt{FilmeBean}]{Métodos da classe \texttt{FilmeBean}. \textbf{Fonte:} Elaborado pelos autores.}}, label=fig:metodosclassebean] 	
	public FilmeBean(){  
       movieTo = new MovieTO();
       movieDAO = new MovieDAO();
       actorDao = new ActorDAO();       
       getContructListActors();
   	}	
   	
	public void saveMovie(){
		setListActorSelected();		
		if(this.movieDAO.saveMovieGraph(this.movieTo)){
			FacesContext.getCurrentInstance().addMessage(null, 
			   new FacesMessage("Filme cadastrado com sucesso!")); 
		}else{
			FacesContext.getCurrentInstance().addMessage(null, new 
					FacesMessage(FacesMessage.SEVERITY_ERROR,
							"Houve algum erro no cadastro do filme!", 
							this.movieTo.getTitle()));  
		}		
		this.limpaCampos();
	}
	
	public void setListActorSelected(){
		ArrayList<String> arrayActor = new ArrayList<String>();
		for (String ator:listActors.getTarget()) { arrayActor.add(ator); }
		movieTo.setActors(arrayActor);
	}
\end{lstlisting}



\par Após a execução dos processos de desenvlvimento descritos, a
Figura~\ref{fig:imgtelacadastrodefilme} ilustra o resultado da tela final de cadastro de filme.

%\par Com a implementação da página XHTML e a classe \texttt{FilmeBean} finalizada 

\begin{figure}[ht!]
  \centerline{\includegraphics[scale=.4]{./imagens/img_sistema_cadastroFilme.png}}
  \caption[Tela de cadastro de filme]{Tela de cadastro de filme. \textbf{Fonte:} Elaborado
  pelos autores}
\label{fig:imgtelacadastrodefilme}
\end{figure}

\subsubsection{Regras de recomendação}
\par Sendo esta fase do trabalho referente à construção de um aplicativo
que realize uma recomendação de filmes, foi fundamental a criação das regras, 
que viabilizem este processo, sendo assim, houve a necessidade de elaborar os relacionamentos, 
que seriam construídos após o usuário realizar uma locação de um filme, 
desta forma tornando possível obter uma recomendação válida.
\par Para isto, foram definidas duas regras utilizadas no projeto:

\begin{enumerate}
  \item \textbf{Filme assistido}: Esta primeira regra, para que haja a recomendação, é apresentado na Figura~\ref{fig:imgregra1recomendacao}, 
sendo o relacionamento de um determinado usuário a um filme, 
determinando a ligação de um vértice \texttt{User} ao vértice \texttt{Movie}. 
Este relacionamento é o principal meio utilizado para se ter uma referência do perfil do usuário,
se tornando necessário sua criação. Caso este relacionamento não existisse,
isso indicaria que o usuário não teria alugado nenhum filme, sendo impossível uma recomendação, 
já que não haveriam relacionamentos
que possibilitassem efetuar a busca com retorno de valores no banco de dados orientado a grafo. 

\begin{figure}[h!]
  \centerline{\includegraphics[scale=.8]{./imagens/recomendacao_regra_1_simplificado.jpg}}
  \caption[Relacionamento utilizado na regra de recomendação]{Relacionamento utilizado na regra de recomendação. \textbf{Fonte:} Elaborado
  pelos autores}
\label{fig:imgregra1recomendacao}
\end{figure}

  \item \textbf{O ator ou gênero devem possuir referência de outros filmes}: Para que possa ocorrer efetivamente a recomendação 
  de um filme é utilizado a referência de um gênero ou ator, ilustrado na Figura~\ref{fig:imgregra2recomendacao}, que mostra os relacionamentos de \texttt{BELONGS} e \texttt{SERVED} do filme com o gênero e ator, respectivamente.

\begin{figure}[h!]
  \centerline{\includegraphics[scale=.8]{./imagens/recomendacao_regra_2_simplificado.jpg}}
  \caption[Modelo 2 regra de recomendação]{Modelo 2 regra de recomendação. \textbf{Fonte:} Elaborado
  pelos autores}
\label{fig:imgregra2recomendacao}
\end{figure}

\par Estes relacionamentos são o ponto chave da recomendação, 
sendo eles os fatores decisivos para o retorno de uma lista de filmes, 
lembrando que um determinado gênero pode pertencer a vários filmes e um ator 
pode ter atuado em vários filmes. Assim, o usuário ao requisitar uma recomendação por gênero, 
será realizada a busca dos filmes no qual ele ainda não possui nenhum relacionamento, 
retornando uma lista dos filmes contendo o mesmo gênero. 
Este mesmo procedimento se aplica aos atores contendo a única distinção na qual os filmes 
retornados através da recomendação de atores podem conter gêneros diferentes no qual 
o ator teve sua participação. 

\end{enumerate}

\par Após a definição das regras, foi iniciado a construção da aplicação 
respeitando as regras  propostas para a implementação da recomendação 
utilizando o banco de dados orientado a grafo Neo4J.

\par Com isso, é finalizada  a metodologia de desenvolvimento utilizada para a
o desenvolvimento do projeto. O próximo capítulo apresentará os resultados
obtidos.
